/**
 * 
 */
package ec.edu.uce.erp.ejb.servicio.impl;

import java.util.List;

import javax.ejb.EJB;
import javax.ejb.Stateless;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import ec.edu.uce.erp.common.util.ConstantesApplication;
import ec.edu.uce.erp.common.util.EncriptacionUtil;
import ec.edu.uce.erp.common.util.SeguridadesException;
import ec.edu.uce.erp.common.util.UtilAplication;
import ec.edu.uce.erp.ejb.persistence.dao.FactoryDAO;
import ec.edu.uce.erp.ejb.persistence.entity.Empresa;
import ec.edu.uce.erp.ejb.persistence.entity.security.Menu;
import ec.edu.uce.erp.ejb.persistence.entity.security.Modulo;
import ec.edu.uce.erp.ejb.persistence.entity.security.Perfil;
import ec.edu.uce.erp.ejb.persistence.entity.security.Usuario;
import ec.edu.uce.erp.ejb.servicio.ServicioAdministracion;

/**
 * @author
 *
 */
@Stateless
public class ServicioAdministracionImpl implements ServicioAdministracion {
	
	private static final Logger slf4jLogger = LoggerFactory.getLogger(ServicioAdministracionImpl.class);
	
	@EJB 
	private FactoryDAO factoryDAO;

	@Override
	public Empresa registrarEmpresa(Empresa empresa) throws SeguridadesException {
		slf4jLogger.info("registrarEmpresa");
		
		Empresa empresaNueva = null;
		
		try {
			
			if (empresaRepetida(empresa)) {
				throw new SeguridadesException("Ya se encuentra registrada una empresa con ese nombre");
			}
			
//			if (StringUtils.isEmpty(empresa.getEstado())) {
//				empresa.setEstado(ConstantesApplication.ESTADO_ACTIVO);
//			}
//			empresa.setFechaRegistro(UtilAplication.obtenerFechaActual());
			empresaNueva = factoryDAO.getEmpresaDAOImpl().create(empresa);
			
		} catch (Exception e) {
			slf4jLogger.info("Error al registrar la empresa {}", e.getMessage());
			throw new SeguridadesException("No se pudo registrar la empresa");
		}
		return empresaNueva;
	}
	
	private Boolean empresaRepetida (Empresa empresa) throws SeguridadesException {
		
		Empresa empresaPlantilla = new Empresa();
//		empresaPlantilla.setNombreEmpresa(empresa.getNombreEmpresa());
		
		List<Empresa> dtos = factoryDAO.getEmpresaDAOImpl().obtenerEmpresaCriterios(empresaPlantilla);
		
		if (CollectionUtils.isEmpty(dtos)) {
			return Boolean.FALSE;
		} 
		
		return Boolean.TRUE;
	}

	@Override
	public Empresa actualizarEmpresa(Empresa empresa) throws SeguridadesException {
		slf4jLogger.info("actualizarEmpresa");
		try {
//			empresa.setFechaModificacion(UtilAplication.obtenerFechaActual());
			return factoryDAO.getEmpresaDAOImpl().update(empresa);
			
		} catch (Exception e) {
			slf4jLogger.info("Error al actualizar la empresa {}", e.getMessage());
			throw new SeguridadesException("No se pudo actualizar la empresa");
		}
	}

	@Override
	public List<Empresa> buscarEmpresa(Empresa empresa) throws SeguridadesException {
		slf4jLogger.info("buscarEmpresa");
		try {
			return factoryDAO.getEmpresaDAOImpl().obtenerEmpresaCriterios(empresa);
		} catch (Exception e) {
			slf4jLogger.info("Error al buscar la empresa {}", e.getMessage());
			throw new SeguridadesException("No se pudo obtener las empresas de la base de datos");
		}
	}

	@Override
	public Modulo registrarModulo(Modulo modulo) throws SeguridadesException {
		
		Modulo moduloNuevo = null;
		
		slf4jLogger.info("registrarModulo");
		try {
			modulo.setIdModulo(null);
			modulo.setEstado(ConstantesApplication.ESTADO_ACTIVO);
			modulo.setFechaRegistro(UtilAplication.obtenerFechaActual());
			moduloNuevo = factoryDAO.getModuloDAOImpl().create(modulo);
			
		} catch (Exception e) {
			slf4jLogger.info("Error al registrar el modulo {}", e.getMessage());
			throw new SeguridadesException("No se pudo registrar el m\u00F3dulo");
		} finally {
			if (moduloNuevo == null) {
				throw new SeguridadesException("Error registrar el m\u00F3dulo");
			}
		}
		return moduloNuevo;
	}

	@Override
	public List<Perfil> buscarPerfiles(Perfil perfil) throws SeguridadesException {
		slf4jLogger.info("buscarPerfiles");
		
		List<Perfil> perfilCol = null;
		 
		try {
			perfilCol = factoryDAO.getPerfilDAOImpl().obtenerPerfilCriterios(perfil);
			
			if (CollectionUtils.isNotEmpty(perfilCol)) {
				CollectionUtils.select(perfilCol, new Predicate() {
					
					@Override
					public boolean evaluate(Object arg0) {
						Perfil perfil = (Perfil)arg0;
						perfil.getSegtModulos().size();
						perfil.getSegtUsuarios().size();
						return true;
					}
				});
			}
			
		} catch (Exception e) {
			slf4jLogger.info("Error al buscar los perfiles de la bd {}", e.getMessage());
			throw new SeguridadesException("No se pudo obtener los perfiles de la base de datos");
		}
		
		return perfilCol;
	}
	
	@Override
	public List<Perfil> buscarPerfileEmpresa(Perfil perfil) throws SeguridadesException {
		slf4jLogger.info("buscarPerfileEmpresa");
		try {
			return factoryDAO.getPerfilDAOImpl().obtenerPerfilEmpresa(perfil);
		} catch (Exception e) {
			slf4jLogger.info("Error al buscarPerfileEmpresa de la bd {}", e.getMessage());
			throw new SeguridadesException("No se pudo obtener los perfiles de la base de datos");
		}
	}

	

	@Override
	public Modulo actualizarModulo(Modulo modulo) throws SeguridadesException {
		slf4jLogger.info("actualizarModulo");
		try {
			
			modulo.setFechaModificacion(UtilAplication.obtenerFechaActual());
			return factoryDAO.getModuloDAOImpl().update(modulo);
			
		} catch (Exception e) {
			slf4jLogger.info("Error al actualizar el modulo {}", e.getMessage());
			throw new SeguridadesException ("No se pudo actualizar el modulo en la base de datos");
		}
	}

	@Override
	public List<Modulo> buscarModulos(Modulo modulo) throws SeguridadesException {
		
		slf4jLogger.info("buscarModulos");
		
		try {
			return factoryDAO.getModuloDAOImpl().obtenerModuloCriterios(modulo);
		} catch (Exception e) {
			slf4jLogger.info("Error al buscar los modulos de la bd {}", e.getMessage());
			throw new SeguridadesException("No se pudo obtener los modulos de la base de datos");
		}
		
	}

	@Override
	public Menu registrarMenu(Menu menu) throws SeguridadesException {
		slf4jLogger.info("registrarMenu");
		try {
			menu.setFechaRegistro(UtilAplication.obtenerFechaActual());
			return factoryDAO.getMenuDAOImpl().create(menu);
			
		} catch (Exception e) {
			slf4jLogger.info("Error al registrar el menu {}", e.getMessage());
			throw new SeguridadesException("No se pudo registrar el menu");
		}
	}

	@Override
	public Menu actualizarMenu(Menu menu) throws SeguridadesException {
		slf4jLogger.info("actualizarMenu");
		try {
			menu.setFechaModificacion(UtilAplication.obtenerFechaActual());
			return factoryDAO.getMenuDAOImpl().update(menu);
		} catch (Exception e) {
			slf4jLogger.info("No se pudo actualizar el menu {}" , e.getMessage());
			throw new SeguridadesException("No se pudo actualizar el menu");
		}
	}

	@Override
	public List<Menu> buscarMenu(Menu menu) throws SeguridadesException {
		slf4jLogger.info("buscarMenu");
		try {
			return factoryDAO.getMenuDAOImpl().buscarMenuCriterios(menu);
		} catch (Exception e) {
			slf4jLogger.info("No se pudo buscarMenu {}" , e.getMessage());
			throw new SeguridadesException("No se pudo buscar el menu en la base de datos");
		}
	}

	@Override
	public Perfil registrarPerfil(Perfil perfil) throws SeguridadesException {
		slf4jLogger.info("registrarPerfil");
		
		Perfil perfilNuevo = null;
		
		try {
			perfil.setEstado(ConstantesApplication.ESTADO_ACTIVO);
			perfil.setFechaRegistro(UtilAplication.obtenerFechaActual());
			perfilNuevo = factoryDAO.getPerfilDAOImpl().create(perfil);
			
		} catch (Exception e) {
			slf4jLogger.info("Error al registrar el perfil {}", e.getMessage());
			throw new SeguridadesException("No se pudo registrar el perfil");
		}
		
		return perfilNuevo;
	}

	@Override
	public Perfil actualizarPerfil(Perfil perfil) throws SeguridadesException {
		slf4jLogger.info("actualizarPerfil");
		try {
			perfil.setFechaModificacion(UtilAplication.obtenerFechaActual());
			return factoryDAO.getPerfilDAOImpl().update(perfil);
		} catch (Exception e) {
			slf4jLogger.info("No se pudo actualizar el perfil {}" , e.getMessage());
			throw new SeguridadesException("No se pudo actualizar el perfil");
		}
	}
	
	/*
	 * Metodos para la administracion del usuario
	 */
	
	@Override
	public Usuario registrarUsuario(Usuario usuario) throws SeguridadesException {
		slf4jLogger.info("registrarUsuario");
		try {
			usuario.setFechaRegistro(UtilAplication.obtenerFechaActual());
			usuario.setPassUsuario(EncriptacionUtil.getInstancia().encriptar(usuario.getLoginUsuario()));
			usuario.setEstado(ConstantesApplication.ESTADO_ACTIVO);
			return factoryDAO.getUsuarioDAOImpl().create(usuario);
			
		} catch (Exception e) {
			slf4jLogger.info("Error al registrar el usuario {}", e.getMessage());
			throw new SeguridadesException("No se pudo registrar el usuario");
		}
	}

	@Override
	public Usuario actualizarUsuario(Usuario usuario) throws SeguridadesException {
		slf4jLogger.info("actualizarUsuario");
		try {
			usuario.setFechaModificacion(UtilAplication.obtenerFechaActual());
			return factoryDAO.getUsuarioDAOImpl().update(usuario);
		} catch (Exception e) {
			slf4jLogger.info("No se pudo actulizar el usuario {}" , e.getMessage());
			throw new SeguridadesException("No se pudo actualizar el usuario");
		}
	}

	@Override
	public List<Usuario> buscarUsuarios(Usuario usuario) throws SeguridadesException {
		slf4jLogger.info("buscarUsuarios");
		
		List<Usuario> usuariosCol = null;
		
//		usuariosCol = factoryDAO.getUsuarioDAOImpl().
		
		return usuariosCol;
	}

	

}
